package com.ruoyi.business.service.impl;

import com.alibaba.fastjson.JSON;
import com.ruoyi.business.domain.CarPackageAudit;
import com.ruoyi.business.domain.ServiceItem;
import com.ruoyi.business.mapper.ServiceItemMapper;
import com.ruoyi.business.service.ICarPackageAuditService;
import com.ruoyi.business.service.IDefinitionNodeService;
import com.ruoyi.business.service.IProcessService;
import com.ruoyi.business.service.IServiceItemService;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.text.Convert;
import com.ruoyi.common.exception.BusinessException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.ShiroUtils;
import com.ruoyi.system.service.ISysUserService;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 养修服务项Service业务层处理
 * 
 * @author wolfcode
 * @date 2021-07-20
 */
@Service
public class ServiceItemServiceImpl implements IServiceItemService
{
    @Autowired
    private ServiceItemMapper serviceItemMapper;
    @Autowired
    private ICarPackageAuditService carPackageAuditService;
    @Autowired
    private IProcessService processService;
    @Autowired
    private IDefinitionNodeService definitionNodeService;
    /**
     * 查询养修服务项
     * 
     * @param id 养修服务项ID
     * @return 养修服务项
     */
    @Override
    public ServiceItem selectServiceItemById(Long id)
    {
        return serviceItemMapper.selectServiceItemById(id);
    }

    /**
     * 查询养修服务项列表
     * 
     * @param serviceItem 养修服务项
     * @return 养修服务项
     */
    @Override
    public List<ServiceItem> selectServiceItemList(ServiceItem serviceItem)
    {
        return serviceItemMapper.selectServiceItemList(serviceItem);
    }

    /**
     * 新增养修服务项
     * 
     * @param serviceItem 养修服务项
     * @return 结果
     */
    @Override
    public int insertServiceItem(ServiceItem serviceItem)
    {
        serviceItem.setCreateTime(DateUtils.getNowDate());
        if(ServiceItem.CARPACKAGE_YES.equals(serviceItem.getCarPackage())){
            serviceItem.setAuditStatus(ServiceItem.AUDITSTATUS_INIT);//设置初始化
        }
        return serviceItemMapper.insertServiceItem(serviceItem);
    }

    /**
     * 修改养修服务项
     * 
     * @param serviceItem 养修服务项
     * @return 结果
     */
    @Override
    public int updateServiceItem(ServiceItem serviceItem)
    {
        ServiceItem oldObj = selectServiceItemById(serviceItem.getId());
        //处于上架状态的商品不能修改
        if(ServiceItem.SALESTATUS_ON.equals(oldObj.getSaleStatus())){
            throw new BusinessException("上架服务项目不能修改，请下架后再修改");
        }else if(ServiceItem.AUDITSTATUS_AUDITING.equals(oldObj.getAuditStatus())){
            throw new BusinessException("服务项目正在审核中,不可修改");
        }
        //如果是审核通过，此时修改，需要将其状态变更为初始化
        if(ServiceItem.AUDITSTATUS_APPROVED.equals(oldObj.getAuditStatus())){
            serviceItem.setAuditStatus(ServiceItem.AUDITSTATUS_INIT);
        }
        serviceItem.setVersion(oldObj.getVersion());
        return serviceItemMapper.updateServiceItem(serviceItem);
    }
    /**
     * 删除养修服务项对象
     * 
     * @param ids 需要删除的数据ID
     * @return 结果
     */
    @Override
    public int deleteServiceItemByIds(String ids)
    {
        return serviceItemMapper.deleteServiceItemByIds(Convert.toStrArray(ids));
    }
    /**
     * 下架
     *
     * @param id 需要下架的服务项ID
     * @return
     */
    @Override
    public int saleOff(Long id) {
        return serviceItemMapper.changeSaleStatus(id,ServiceItem.SALESTATUS_OFF);
    }
    /**
     * 上架
     * @param id 需要上架的服务ID
     * @return
     */
    @Override
    public int saleOn(Long id) {
        ServiceItem serviceItem = selectServiceItemById(id);
        //如果不是套餐，可以直接上架
        //如果是套餐，只有审核成功才能上架
        if(ServiceItem.CARPACKAGE_YES.equals(serviceItem.getCarPackage())
                && !ServiceItem.AUDITSTATUS_APPROVED.equals(serviceItem.getAuditStatus())){
            throw new BusinessException("套餐服务项需要审核通过之后才能上架");
        }
        return serviceItemMapper.changeSaleStatus(id,ServiceItem.SALESTATUS_ON);
    }
    /**
     * 查询上架的养修服务项列表
     *
     * @param serviceItem 养修服务项
     * @return 养修服务项集合
     */
    @Override
    public List<ServiceItem> selectAllSaleOnList(ServiceItem serviceItem) {
        return serviceItemMapper.selectAllSaleOnList(serviceItem);
    }
    //开始审核
    @Override
    @Transactional
    public void startAudit(Long id) {
        ServiceItem serviceItem = serviceItemMapper.selectServiceItemById(id);
        if(!serviceItem.getAuditStatus().equals(ServiceItem.AUDITSTATUS_INIT)){
            throw new BusinessException("非法操作,只有初始化状态服务项才能发起审核");
        }
        serviceItem.setAuditStatus(ServiceItem.AUDITSTATUS_AUDITING);
        //状态更新为审核中
        serviceItemMapper.updateServiceItem(serviceItem);
        CarPackageAudit carPackageAudit = new CarPackageAudit();
        carPackageAudit.setServiceItemInfo(JSON.toJSONString(serviceItem));//快照   对象转JSON字符串
        carPackageAudit.setCreateBy(ShiroUtils.getUserId().toString());
        carPackageAuditService.insertCarPackageAudit(carPackageAudit);
        //启动流程
        Map<String, Object> variables = new HashMap<>();// 创建流程变量
        variables.put("money",serviceItem.getDiscountPrice().longValue());//金额是全局变量
        String businessKey = carPackageAudit.getId().toString();
        // 在启动时设置流程变量    processEngine.getRuntimeService()
        ProcessInstance instance = processService
                .startProcessInstanceByKey(CarPackageAudit.DEFINITION_KEY,businessKey,variables);
        //查询当前任务节点=>候选人
        Task currentTask = processService.getTaskByInstanceId(instance.getId());
        //获取任务节点key
       // String name = currentTask.getName();
        String taskDefinitionKey = currentTask.getTaskDefinitionKey();//key值   t_definition_node
        //根据节点的key查询对应的审核人集合
        List<SysUser> auditors = definitionNodeService
                .queryAuditorsByTaskDefinitionKey(taskDefinitionKey);
        List<String> auditorsName = new ArrayList<>();
        auditors.forEach(sysUser -> {
            processService.addCandidateUser(currentTask.getId(), sysUser.getUserId().toString());//Long转为string
            auditorsName.add(sysUser.getUserName());
        });
        //更新审核列表对象
        carPackageAudit.setProcessDefinitionId(instance.getProcessDefinitionId());
        carPackageAudit.setAuditors(JSON.toJSONString(auditorsName));
        carPackageAudit.setInstanceId(instance.getId());
        //SQL语句改数据库
        carPackageAuditService.updateCarPackageAudit(carPackageAudit);
    }

    @Override
    public void updateServiceItemNoCondition(ServiceItem serviceItem) {
        serviceItemMapper.updateServiceItemNoCondition(serviceItem);
    }
}